package com.stu.designpattern;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.io.*;

/**
 * Java设计模式演示
 * 
 * 本类演示了常用的设计模式，包括：
 * 1. 创建型模式：单例、工厂、建造者、原型
 * 2. 结构型模式：适配器、装饰器、代理、外观
 * 3. 行为型模式：观察者、策略、模板方法、责任链
 * 
 * 设计模式是解决特定问题的经典解决方案，
 * 它们代表了面向对象设计的最佳实践。
 * 
 * @author 学习者
 * @version 1.0
 * @since JDK 1.8
 */
public class DesignPatternDemo {
    
    /**
     * 主方法：演示各种设计模式
     */
    public static void main(String[] args) {
        System.out.println("=== Java设计模式演示 ===");
        
        try {
            // 1. 创建型模式
            demonstrateCreationalPatterns();
            
            // 2. 结构型模式
            demonstrateStructuralPatterns();
            
            // 3. 行为型模式
            demonstrateBehavioralPatterns();
            
            // 4. 设计模式总结
            summarizeDesignPatterns();
            
        } catch (Exception e) {
            System.err.println("演示过程中发生错误：" + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 演示创建型模式
     */
    private static void demonstrateCreationalPatterns() {
        System.out.println("\n=== 创建型模式演示 ===");
        
        System.out.println("创建型模式：关注对象的创建过程");
        System.out.println("主要解决：对象创建的复杂性和灵活性问题");
        
        // 1. 单例模式
        demonstrateSingletonPattern();
        
        // 2. 工厂模式
        demonstrateFactoryPattern();
        
        // 3. 建造者模式
        demonstrateBuilderPattern();
        
        // 4. 原型模式
        demonstratePrototypePattern();
    }
    
    /**
     * 演示单例模式
     */
    private static void demonstrateSingletonPattern() {
        System.out.println("\n--- 单例模式 ---");
        System.out.println("目的：确保一个类只有一个实例，并提供全局访问点");
        System.out.println("应用场景：配置管理、日志记录、数据库连接池等");
        
        // 饿汉式单例
        System.out.println("\n1. 饿汉式单例：");
        EagerSingleton eager1 = EagerSingleton.getInstance();
        EagerSingleton eager2 = EagerSingleton.getInstance();
        System.out.println("两个实例是否相同：" + (eager1 == eager2));
        eager1.doSomething();
        
        // 懒汉式单例
        System.out.println("\n2. 懒汉式单例：");
        LazySingleton lazy1 = LazySingleton.getInstance();
        LazySingleton lazy2 = LazySingleton.getInstance();
        System.out.println("两个实例是否相同：" + (lazy1 == lazy2));
        lazy1.doSomething();
        
        // 双重检查锁单例
        System.out.println("\n3. 双重检查锁单例：");
        DoubleCheckSingleton dc1 = DoubleCheckSingleton.getInstance();
        DoubleCheckSingleton dc2 = DoubleCheckSingleton.getInstance();
        System.out.println("两个实例是否相同：" + (dc1 == dc2));
        dc1.doSomething();
        
        // 枚举单例
        System.out.println("\n4. 枚举单例：");
        EnumSingleton enum1 = EnumSingleton.INSTANCE;
        EnumSingleton enum2 = EnumSingleton.INSTANCE;
        System.out.println("两个实例是否相同：" + (enum1 == enum2));
        enum1.doSomething();
        
        System.out.println("\n单例模式要点：");
        System.out.println("1. 构造器私有化");
        System.out.println("2. 提供静态获取实例方法");
        System.out.println("3. 考虑线程安全性");
        System.out.println("4. 防止反射和序列化破坏");
        System.out.println("5. 枚举是最佳实现方式");
    }
    
    /**
     * 演示工厂模式
     */
    private static void demonstrateFactoryPattern() {
        System.out.println("\n--- 工厂模式 ---");
        System.out.println("目的：创建对象而不暴露创建逻辑，通过接口引用新创建的对象");
        System.out.println("应用场景：数据库驱动、日志框架、GUI组件等");
        
        // 简单工厂
        System.out.println("\n1. 简单工厂：");
        Shape circle = ShapeFactory.createShape("CIRCLE");
        Shape rectangle = ShapeFactory.createShape("RECTANGLE");
        Shape triangle = ShapeFactory.createShape("TRIANGLE");
        
        circle.draw();
        rectangle.draw();
        triangle.draw();
        
        // 工厂方法
        System.out.println("\n2. 工厂方法：");
        AnimalFactory dogFactory = new DogFactory();
        AnimalFactory catFactory = new CatFactory();
        
        Animal dog = dogFactory.createAnimal();
        Animal cat = catFactory.createAnimal();
        
        dog.makeSound();
        cat.makeSound();
        
        // 抽象工厂
        System.out.println("\n3. 抽象工厂：");
        GUIFactory windowsFactory = new WindowsFactory();
        GUIFactory macFactory = new MacFactory();
        
        Button winButton = windowsFactory.createButton();
        TextField winTextField = windowsFactory.createTextField();
        
        Button macButton = macFactory.createButton();
        TextField macTextField = macFactory.createTextField();
        
        winButton.click();
        winTextField.input("Windows文本");
        
        macButton.click();
        macTextField.input("Mac文本");
        
        System.out.println("\n工厂模式要点：");
        System.out.println("1. 简单工厂：一个工厂类创建所有产品");
        System.out.println("2. 工厂方法：每个产品有对应的工厂");
        System.out.println("3. 抽象工厂：创建产品族");
        System.out.println("4. 解耦对象创建和使用");
        System.out.println("5. 符合开闭原则");
    }
    
    /**
     * 演示建造者模式
     */
    private static void demonstrateBuilderPattern() {
        System.out.println("\n--- 建造者模式 ---");
        System.out.println("目的：使用多个简单对象一步步构建复杂对象");
        System.out.println("应用场景：复杂对象构建、SQL构建器、配置对象等");
        
        // 传统建造者模式
        System.out.println("\n1. 传统建造者模式：");
        ComputerDirector director = new ComputerDirector();
        
        ComputerBuilder gamingBuilder = new GamingComputerBuilder();
        Computer gamingComputer = director.construct(gamingBuilder);
        System.out.println("游戏电脑：" + gamingComputer);
        
        ComputerBuilder officeBuilder = new OfficeComputerBuilder();
        Computer officeComputer = director.construct(officeBuilder);
        System.out.println("办公电脑：" + officeComputer);
        
        // 链式建造者模式
        System.out.println("\n2. 链式建造者模式：");
        Person person = new Person.Builder()
                .name("张三")
                .age(25)
                .email("zhangsan@example.com")
                .phone("13800138000")
                .address("北京市朝阳区")
                .build();
        
        System.out.println("构建的人员信息：" + person);
        
        // SQL建造者示例
        System.out.println("\n3. SQL建造者示例：");
        String sql = new SQLBuilder()
                .select("name", "age", "email")
                .from("users")
                .where("age > 18")
                .and("status = 'active'")
                .orderBy("name ASC")
                .limit(10)
                .build();
        
        System.out.println("构建的SQL：" + sql);
        
        System.out.println("\n建造者模式要点：");
        System.out.println("1. 分步骤构建复杂对象");
        System.out.println("2. 相同构建过程创建不同表示");
        System.out.println("3. 链式调用提高可读性");
        System.out.println("4. 参数校验和默认值设置");
        System.out.println("5. 不可变对象的理想创建方式");
    }
    
    /**
     * 演示原型模式
     */
    private static void demonstratePrototypePattern() {
        System.out.println("\n--- 原型模式 ---");
        System.out.println("目的：通过复制现有实例来创建新实例");
        System.out.println("应用场景：对象创建成本高、需要大量相似对象等");
        
        try {
            // 浅拷贝
            System.out.println("\n1. 浅拷贝：");
            ShallowPrototype original = new ShallowPrototype("原始对象", new ArrayList<>(Arrays.asList("item1", "item2")));
            ShallowPrototype shallowCopy = (ShallowPrototype) original.clone();
            
            System.out.println("原始对象：" + original);
            System.out.println("浅拷贝对象：" + shallowCopy);
            System.out.println("对象是否相同：" + (original == shallowCopy));
            System.out.println("列表是否相同：" + (original.getItems() == shallowCopy.getItems()));
            
            // 修改列表内容
            original.getItems().add("item3");
            System.out.println("修改原始对象列表后：");
            System.out.println("原始对象：" + original);
            System.out.println("浅拷贝对象：" + shallowCopy);
            
            // 深拷贝
            System.out.println("\n2. 深拷贝：");
            DeepPrototype deepOriginal = new DeepPrototype("深拷贝原始对象", new ArrayList<>(Arrays.asList("deep1", "deep2")));
            DeepPrototype deepCopy = (DeepPrototype) deepOriginal.clone();
            
            System.out.println("原始对象：" + deepOriginal);
            System.out.println("深拷贝对象：" + deepCopy);
            System.out.println("对象是否相同：" + (deepOriginal == deepCopy));
            System.out.println("列表是否相同：" + (deepOriginal.getItems() == deepCopy.getItems()));
            
            // 修改列表内容
            deepOriginal.getItems().add("deep3");
            System.out.println("修改原始对象列表后：");
            System.out.println("原始对象：" + deepOriginal);
            System.out.println("深拷贝对象：" + deepCopy);
            
            // 原型管理器
            System.out.println("\n3. 原型管理器：");
            PrototypeManager manager = new PrototypeManager();
            
            // 注册原型
            manager.addPrototype("user", new UserPrototype("模板用户", "template@example.com"));
            manager.addPrototype("admin", new AdminPrototype("管理员模板", "admin@example.com", "ALL"));
            
            // 克隆原型
            UserPrototype user1 = (UserPrototype) manager.getPrototype("user");
            UserPrototype user2 = (UserPrototype) manager.getPrototype("user");
            AdminPrototype admin1 = (AdminPrototype) manager.getPrototype("admin");
            
            user1.setName("张三");
            user1.setEmail("zhangsan@example.com");
            
            user2.setName("李四");
            user2.setEmail("lisi@example.com");
            
            admin1.setName("管理员王五");
            admin1.setEmail("wangwu@example.com");
            
            System.out.println("用户1：" + user1);
            System.out.println("用户2：" + user2);
            System.out.println("管理员：" + admin1);
            
        } catch (CloneNotSupportedException e) {
            System.err.println("克隆失败：" + e.getMessage());
        }
        
        System.out.println("\n原型模式要点：");
        System.out.println("1. 实现Cloneable接口");
        System.out.println("2. 重写clone()方法");
        System.out.println("3. 区分浅拷贝和深拷贝");
        System.out.println("4. 原型管理器统一管理");
        System.out.println("5. 避免复杂对象的重复创建");
    }
    
    /**
     * 演示结构型模式
     */
    private static void demonstrateStructuralPatterns() {
        System.out.println("\n=== 结构型模式演示 ===");
        
        System.out.println("结构型模式：关注类和对象的组合");
        System.out.println("主要解决：如何将类或对象按某种布局组成更大的结构");
        
        // 1. 适配器模式
        demonstrateAdapterPattern();
        
        // 2. 装饰器模式
        demonstrateDecoratorPattern();
        
        // 3. 代理模式
        demonstrateProxyPattern();
        
        // 4. 外观模式
        demonstrateFacadePattern();
    }
    
    /**
     * 演示适配器模式
     */
    private static void demonstrateAdapterPattern() {
        System.out.println("\n--- 适配器模式 ---");
        System.out.println("目的：将一个类的接口转换成客户希望的另一个接口");
        System.out.println("应用场景：系统集成、第三方库适配、接口不兼容等");
        
        // 对象适配器
        System.out.println("\n1. 对象适配器：");
        MediaPlayer audioPlayer = new AudioPlayer();
        
        audioPlayer.play("mp3", "beyond_the_horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far_far_away.vlc");
        audioPlayer.play("avi", "mind_me.avi");
        
        // 类适配器（通过继承）
        System.out.println("\n2. 类适配器：");
        Target target = new ClassAdapter();
        target.request();
        
        System.out.println("\n适配器模式要点：");
        System.out.println("1. 对象适配器使用组合");
        System.out.println("2. 类适配器使用继承");
        System.out.println("3. 解决接口不兼容问题");
        System.out.println("4. 提高类的复用性");
        System.out.println("5. 增加系统的灵活性");
    }
    
    /**
     * 演示装饰器模式
     */
    private static void demonstrateDecoratorPattern() {
        System.out.println("\n--- 装饰器模式 ---");
        System.out.println("目的：动态地给对象添加一些额外的职责");
        System.out.println("应用场景：功能扩展、权限控制、缓存、日志等");
        
        // 基本咖啡
        System.out.println("\n1. 基本装饰：");
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
        
        // 添加牛奶
        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
        
        // 添加糖
        coffee = new SugarDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
        
        // 添加巧克力
        coffee = new ChocolateDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.getCost());
        
        // 流装饰器示例
        System.out.println("\n2. 流装饰器：");
        try {
            String data = "Hello, Decorator Pattern!";
            
            // 创建基础输出流
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            
            // 装饰为缓冲流
            BufferedOutputStream bos = new BufferedOutputStream(baos);
            
            // 装饰为数据流
            DataOutputStream dos = new DataOutputStream(bos);
            
            dos.writeUTF(data);
            dos.flush();
            dos.close();
            
            System.out.println("写入数据：" + data);
            System.out.println("字节数组长度：" + baos.toByteArray().length);
            
        } catch (IOException e) {
            System.err.println("IO操作失败：" + e.getMessage());
        }
        
        System.out.println("\n装饰器模式要点：");
        System.out.println("1. 组合优于继承");
        System.out.println("2. 动态添加功能");
        System.out.println("3. 透明性：装饰后对象与原对象接口相同");
        System.out.println("4. 可以多层装饰");
        System.out.println("5. Java IO流是典型应用");
    }
    
    /**
     * 演示代理模式
     */
    private static void demonstrateProxyPattern() {
        System.out.println("\n--- 代理模式 ---");
        System.out.println("目的：为其他对象提供一种代理以控制对这个对象的访问");
        System.out.println("应用场景：远程代理、虚拟代理、保护代理、智能引用等");
        
        // 静态代理
        System.out.println("\n1. 静态代理：");
        Image image1 = new ProxyImage("test_10mb.jpg");
        Image image2 = new ProxyImage("test_20mb.jpg");
        
        // 图像将从磁盘加载
        image1.display();
        System.out.println("");
        
        // 图像不会从磁盘加载
        image1.display();
        System.out.println("");
        
        // 图像将从磁盘加载
        image2.display();
        System.out.println("");
        
        // 图像不会从磁盘加载
        image2.display();
        
        // 动态代理
        System.out.println("\n2. 动态代理：");
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) java.lang.reflect.Proxy.newProxyInstance(
            userService.getClass().getClassLoader(),
            userService.getClass().getInterfaces(),
            new ServiceInvocationHandler(userService)
        );
        
        proxy.login("admin", "password");
        proxy.logout("admin");
        
        System.out.println("\n代理模式要点：");
        System.out.println("1. 静态代理：编译时确定代理关系");
        System.out.println("2. 动态代理：运行时生成代理类");
        System.out.println("3. 控制对目标对象的访问");
        System.out.println("4. 可以在访问前后添加额外功能");
        System.out.println("5. Spring AOP的核心实现机制");
    }
    
    /**
     * 演示外观模式
     */
    private static void demonstrateFacadePattern() {
        System.out.println("\n--- 外观模式 ---");
        System.out.println("目的：为子系统中的一组接口提供一个一致的界面");
        System.out.println("应用场景：简化复杂系统、分层架构、API封装等");
        
        System.out.println("\n1. 计算机启动外观：");
        ComputerFacade computer = new ComputerFacade();
        computer.start();
        
        System.out.println("");
        computer.shutdown();
        
        System.out.println("\n2. 家庭影院外观：");
        HomeTheaterFacade homeTheater = new HomeTheaterFacade();
        homeTheater.watchMovie("阿凡达");
        
        System.out.println("");
        homeTheater.endMovie();
        
        System.out.println("\n外观模式要点：");
        System.out.println("1. 简化复杂子系统的使用");
        System.out.println("2. 降低客户端与子系统的耦合");
        System.out.println("3. 提供统一的接口");
        System.out.println("4. 不影响客户端直接使用子系统");
        System.out.println("5. 分层架构中的重要模式");
    }
    
    /**
     * 演示行为型模式
     */
    private static void demonstrateBehavioralPatterns() {
        System.out.println("\n=== 行为型模式演示 ===");
        
        System.out.println("行为型模式：关注对象之间的通信");
        System.out.println("主要解决：对象之间的职责分配和算法的抽象化");
        
        // 1. 观察者模式
        demonstrateObserverPattern();
        
        // 2. 策略模式
        demonstrateStrategyPattern();
        
        // 3. 模板方法模式
        demonstrateTemplateMethodPattern();
        
        // 4. 责任链模式
        demonstrateChainOfResponsibilityPattern();
    }
    
    /**
     * 演示观察者模式
     */
    private static void demonstrateObserverPattern() {
        System.out.println("\n--- 观察者模式 ---");
        System.out.println("目的：定义对象间的一对多依赖关系");
        System.out.println("应用场景：事件处理、MVC架构、发布订阅系统等");
        
        // 新闻发布订阅
        System.out.println("\n1. 新闻发布订阅：");
        NewsAgency agency = new NewsAgency();
        
        NewsChannel cnn = new NewsChannel("CNN");
        NewsChannel bbc = new NewsChannel("BBC");
        NewsChannel fox = new NewsChannel("FOX");
        
        agency.addObserver(cnn);
        agency.addObserver(bbc);
        agency.addObserver(fox);
        
        agency.setNews("重大新闻：设计模式学习进展顺利！");
        
        System.out.println("\n移除FOX频道后：");
        agency.removeObserver(fox);
        agency.setNews("最新消息：观察者模式演示完成！");
        
        // 股票价格监控
        System.out.println("\n2. 股票价格监控：");
        Stock appleStock = new Stock("AAPL", 150.0);
        
        Investor investor1 = new Investor("张三");
        Investor investor2 = new Investor("李四");
        
        appleStock.addObserver(investor1);
        appleStock.addObserver(investor2);
        
        appleStock.setPrice(155.0);
        appleStock.setPrice(148.0);
        
        System.out.println("\n观察者模式要点：");
        System.out.println("1. 主题（Subject）维护观察者列表");
        System.out.println("2. 观察者（Observer）定义更新接口");
        System.out.println("3. 松耦合：主题和观察者独立变化");
        System.out.println("4. 支持广播通信");
        System.out.println("5. Java内置Observable/Observer支持");
    }
    
    /**
     * 演示策略模式
     */
    private static void demonstrateStrategyPattern() {
        System.out.println("\n--- 策略模式 ---");
        System.out.println("目的：定义一系列算法，把它们一个个封装起来，并且使它们可相互替换");
        System.out.println("应用场景：支付方式、排序算法、折扣计算等");
        
        // 折扣策略
        System.out.println("\n1. 折扣策略：");
        PriceCalculator calculator = new PriceCalculator();
        double originalPrice = 1000.0;
        
        // 普通客户
        calculator.setDiscountStrategy(new RegularCustomerDiscount());
        System.out.println(calculator.getCurrentStrategyDescription());
        System.out.println("原价：$" + originalPrice + " -> 最终价格：$" + calculator.calculatePrice(originalPrice));
        
        // VIP客户
        calculator.setDiscountStrategy(new VIPCustomerDiscount());
        System.out.println("\n" + calculator.getCurrentStrategyDescription());
        System.out.println("原价：$" + originalPrice + " -> 最终价格：$" + calculator.calculatePrice(originalPrice));
        
        // 超级VIP客户
        calculator.setDiscountStrategy(new SuperVIPCustomerDiscount());
        System.out.println("\n" + calculator.getCurrentStrategyDescription());
        System.out.println("原价：$" + originalPrice + " -> 最终价格：$" + calculator.calculatePrice(originalPrice));
        
        // 支付策略
        System.out.println("\n2. 支付策略：");
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(new Item("笔记本电脑", 5000));
        cart.addItem(new Item("鼠标", 100));
        
        // 信用卡支付
        cart.pay(new CreditCardStrategy("1234567890123456", "John Doe", "123", "12/25"));
        
        // PayPal支付
        cart.pay(new PayPalStrategy("john@example.com", "password"));
        
        // 排序策略
        System.out.println("\n3. 排序策略：");
        SortContext sortContext = new SortContext();
        int[] numbers = {64, 34, 25, 12, 22, 11, 90};
        
        System.out.println("原始数组：" + Arrays.toString(numbers));
        
        // 冒泡排序
        sortContext.setSortStrategy(new BubbleSortStrategy());
        int[] bubbleSorted = sortContext.sort(numbers.clone());
        System.out.println("冒泡排序：" + Arrays.toString(bubbleSorted));
        
        // 快速排序
        sortContext.setSortStrategy(new QuickSortStrategy());
        int[] quickSorted = sortContext.sort(numbers.clone());
        System.out.println("快速排序：" + Arrays.toString(quickSorted));
        
        System.out.println("\n策略模式要点：");
        System.out.println("1. 算法族封装成独立类");
        System.out.println("2. 运行时动态选择算法");
        System.out.println("3. 消除条件语句");
        System.out.println("4. 符合开闭原则");
        System.out.println("5. 组合优于继承的体现");
    }
    
    /**
     * 演示模板方法模式
     */
    private static void demonstrateTemplateMethodPattern() {
        System.out.println("\n--- 模板方法模式 ---");
        System.out.println("目的：定义一个操作中的算法骨架，而将一些步骤延迟到子类中");
        System.out.println("应用场景：框架设计、数据处理流程、游戏AI等");
        
        // 数据处理模板
        System.out.println("\n1. 数据处理模板：");
        DataProcessor csvProcessor = new CsvDataProcessor();
        DataProcessor xmlProcessor = new XmlDataProcessor();
        DataProcessor jsonProcessor = new JsonDataProcessor();
        
        System.out.println("=== CSV数据处理 ===");
        csvProcessor.processData();
        
        System.out.println("\n=== XML数据处理 ===");
        xmlProcessor.processData();
        
        System.out.println("\n=== JSON数据处理 ===");
        jsonProcessor.processData();
        
        // 饮料制作模板
        System.out.println("\n2. 饮料制作模板：");
        Beverage tea = new Tea();
        Beverage coffee = new CoffeeBeverage();
        
        System.out.println("=== 制作茶 ===");
        tea.prepareRecipe();
        
        System.out.println("\n=== 制作咖啡 ===");
        coffee.prepareRecipe();
        
        // 游戏模板
        System.out.println("\n3. 游戏模板：");
        Game football = new Football();
        Game basketball = new Basketball();
        
        System.out.println("=== 足球比赛 ===");
        football.play();
        
        System.out.println("\n=== 篮球比赛 ===");
        basketball.play();
        
        System.out.println("\n模板方法模式要点：");
        System.out.println("1. 定义算法骨架");
        System.out.println("2. 子类实现具体步骤");
        System.out.println("3. 控制子类扩展点");
        System.out.println("4. 代码复用的重要手段");
        System.out.println("5. 好莱坞原则：别调用我们，我们会调用你");
    }
    
    /**
     * 演示责任链模式
     */
    private static void demonstrateChainOfResponsibilityPattern() {
        System.out.println("\n--- 责任链模式 ---");
        System.out.println("目的：避免请求发送者与接收者耦合，让多个对象都有可能接收请求");
        System.out.println("应用场景：审批流程、异常处理、过滤器链等");
        
        // 日志处理链
        System.out.println("\n1. 日志处理链：");
        Logger consoleLogger = new ConsoleLogger(Logger.INFO);
        Logger fileLogger = new FileLogger(Logger.DEBUG);
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        
        consoleLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(errorLogger);
        
        consoleLogger.logMessage(Logger.INFO, "这是一条信息日志");
        consoleLogger.logMessage(Logger.DEBUG, "这是一条调试日志");
        consoleLogger.logMessage(Logger.ERROR, "这是一条错误日志");
        
        // 审批流程链
        System.out.println("\n2. 审批流程链：");
        Approver supervisor = new Supervisor();
        Approver manager = new PurchaseManager();
        Approver director = new PurchaseDirector();
        Approver ceo = new CEO();
        
        supervisor.setNextApprover(manager);
        manager.setNextApprover(director);
        director.setNextApprover(ceo);
        
        PurchaseRequest request1 = new PurchaseRequest("办公用品", 500);
        PurchaseRequest request2 = new PurchaseRequest("服务器", 5000);
        PurchaseRequest request3 = new PurchaseRequest("办公楼装修", 50000);
        PurchaseRequest request4 = new PurchaseRequest("收购公司", 5000000);
        
        System.out.println("\n处理采购请求：");
        supervisor.processRequest(request1);
        System.out.println();
        supervisor.processRequest(request2);
        System.out.println();
        supervisor.processRequest(request3);
        System.out.println();
        supervisor.processRequest(request4);
        
        // 过滤器链
        System.out.println("\n3. 过滤器链：");
        Filter authFilter = new AuthenticationFilter();
        Filter authzFilter = new AuthorizationFilter();
        Filter logFilter = new LoggingFilter();
        
        authFilter.setNext(authzFilter);
        authzFilter.setNext(logFilter);
        
        HttpRequest request = new HttpRequest("admin", "admin", "/admin/users");
        System.out.println("\n处理管理员请求：");
        authFilter.doFilter(request);
        
        HttpRequest guestRequest = new HttpRequest("guest", "user", "/public/info");
        System.out.println("\n处理游客请求：");
        authFilter.doFilter(guestRequest);
        
        System.out.println("\n责任链模式要点：");
        System.out.println("1. 将请求发送者和接收者解耦");
        System.out.println("2. 多个对象都有机会处理请求");
        System.out.println("3. 动态组织和分配责任");
        System.out.println("4. 简化对象间的相互连接");
        System.out.println("5. Servlet过滤器的核心机制");
    }
    
    /**
     * 设计模式总结
     */
    private static void summarizeDesignPatterns() {
        System.out.println("\n=== 设计模式总结 ===");
        
        System.out.println("\n设计模式的核心思想：");
        System.out.println("1. 面向接口编程，而不是面向实现编程");
        System.out.println("2. 优先使用对象组合，而不是类继承");
        System.out.println("3. 封装变化点，将稳定和变化分离");
        
        System.out.println("\n设计原则（SOLID）：");
        System.out.println("S - 单一职责原则：一个类只有一个引起它变化的原因");
        System.out.println("O - 开闭原则：对扩展开放，对修改关闭");
        System.out.println("L - 里氏替换原则：子类必须能够替换其基类");
        System.out.println("I - 接口隔离原则：不应该强迫客户依赖它们不用的方法");
        System.out.println("D - 依赖倒置原则：高层模块不应该依赖低层模块");
        
        System.out.println("\n其他重要原则：");
        System.out.println("• 迪米特法则：只与直接朋友通信");
        System.out.println("• 合成复用原则：优先使用组合而非继承");
        System.out.println("• 好莱坞原则：别调用我们，我们会调用你");
        
        System.out.println("\n模式分类总结：");
        System.out.println("创建型模式（5种）：单例、工厂方法、抽象工厂、建造者、原型");
        System.out.println("结构型模式（7种）：适配器、桥接、组合、装饰器、外观、享元、代理");
        System.out.println("行为型模式（11种）：责任链、命令、解释器、迭代器、中介者、备忘录、观察者、状态、策略、模板方法、访问者");
        
        System.out.println("\n学习建议：");
        System.out.println("1. 理解问题本质，而不是死记硬背");
        System.out.println("2. 在实际项目中应用和验证");
        System.out.println("3. 避免过度设计和模式滥用");
        System.out.println("4. 结合具体场景选择合适的模式");
        System.out.println("5. 持续重构，逐步应用设计模式");
        
        System.out.println("\n=== 设计模式演示完成 ===");
    }
}